﻿/* Autor: Achim Schnell */

using System;
using System.Collections.Generic;
using AppFx.Reflection.Types;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace Tests.Reflection
{
	/// <summary>
	///Dies ist eine Testklasse für "Test_TypeHelper" und soll
	///alle Test_TypeHelper Komponententests enthalten.
	///</summary>
	[TestClass]
	public class Test_TypeHelper
	{
		[TestMethod]
		[Description("Testet, ob der TypeHelper alle vordefinierte Typen / Typen mit Alias, sowie <string> und <Guid> als simpel erkennt.")]
		public void Can_RecognizeSimpleTypes()
		{
			List<Type> simpleTypes = Test_TypeHelper.GetSimpleTypes();
			foreach (Type t in simpleTypes)
				Assert.IsTrue(TypeHelper.IsSimple(t));
		}

		[TestMethod]
		[Description("Testet, ob der TypeHelper die Nullable<T>-Varianten aller vordefinierten Typen / Typen mit Alias als simpel erkennt.")]
		public void Can_RecognizeNullableSimpleTypes()
		{
			List<Type> simpleTypes = GetNullableSimpleTypes();
			foreach (Type t in simpleTypes)
				Assert.IsTrue(TypeHelper.IsSimple(t));
		}

		[TestMethod]
		[ExpectedException(typeof(ArgumentNullException))]
		[Description("Testet, ob der TypeHelper auf die Übergabe eines NULL-Werts mit einer ArgumentNullException reagiert.")]
		public void Throws_ArgumentNullException_IsSimple()
		{
			TypeHelper.IsSimple(null);
		}

		[TestMethod]
		[Description("Testet, ob der TypeHelper eine ArrayList als listenartigen Typ erkennt.")]
		public void Can_RecognizeIEnumerable()
		{
			Assert.IsTrue(TypeHelper.IsIEnumerable(typeof(System.Collections.ArrayList)));
		}

		[TestMethod]
		[Description("Testet, ob der TypeHelper eine List<T> als listenartigen Typ erkennt.")]
		public void Can_RecognizeGenericIEnumerable()
		{
			Assert.IsTrue(TypeHelper.IsIEnumerable(typeof(List<object>)));
		}

		[TestMethod]
		[ExpectedException(typeof(ArgumentNullException))]
		[Description("Testet, ob der TypeHeler auf die Übergabe eines NULL-Wertes mit einer ArgumentNullException reagiert.")]
		public void Throws_ArgumentNulLException_IsIEnumerable()
		{
			TypeHelper.IsIEnumerable(null);
		}

		[TestMethod]
		[Description("Testet, ob der TypeHelper komplexe Typen als nicht-simpel erkennt.")]
		public void Can_DenyNonSimpleType()
		{
			Assert.IsFalse(TypeHelper.IsSimple(typeof(object)));
		}

		[TestMethod]
		[Description("Testet, ob der TypeHelper nicht-listenartige Typen als solche erkennt.")]
		public void Can_DenyNonListType()
		{
			Assert.IsFalse(TypeHelper.IsIEnumerable(typeof(object)));
		}

		private static List<Type> GetSimpleTypes()
		{
			List<Type> simpleTypes = new List<Type>();
			simpleTypes.AddRange(
				new Type[]
				{
					typeof(bool), 
					typeof(char),
					typeof(byte), typeof(sbyte),
					typeof(decimal), typeof(double), typeof(float),
					typeof(short), typeof(ushort),
					typeof(int), typeof(uint),
					typeof(long), typeof(ulong),
					typeof(string), typeof(Guid)
				});
			return simpleTypes;
		}

		private static List<Type> GetNullableSimpleTypes()
		{
			List<Type> nullableSimpleTypes = Test_TypeHelper.GetSimpleTypes();
			nullableSimpleTypes.Remove(typeof(string));
			nullableSimpleTypes.Remove(typeof(Guid));
			return nullableSimpleTypes;
		}
	}
}
